    test("JavaConcepts.java", function(assert) {
      var src = multiline(function(){/*
        package japa.bdd.samples;

        import com.github.javaparser.JavaParser;

        import japa.parser.ParseException;
        import com.github.javaparser.ast.CompilationUnit;
        import org.junit.Ignore;

        import java.io.*;
        import java.util.*;

        @Ignore
        @Deprecated
        public class JavaConcepts<T extends List<int[]>, X> extends Base implements Serializable {

            static Class clz1 = String.class;

            protected Class clz2 = (String.class);

            Class clz3 = int.class;

            Class clz4 = (int.class);

            int[] arr = new int[10];

            byte bye = 0;

            byte byebye[] = null;

            short sh1, sh2 = 1;

            int intWithUnderscore = 1234_5678;

            long longWithUnderscore = 1234_5678L;

            float floatWithUnderscore = 1_234.5_678f;

            float floatWithUnderscoreAndExponent = 1_234e1_0f;

            double doubleWithUnderscore = 1_234.5_678;

            double doubleWithUnderscoreAndExponent = 1_234e1_0;

            int binaryLiteral = 0b101101;

            List<String>[][] arrLS = (List<String>[][]) new List<?>[10][];

            ;

            {
                int z = 0, y = 0;
                int a = (z) + y;
                a = (+z) + y;
                byte b = (byte) +y;
            }

            List<String> diamond1 = new LinkedList<>();

            @Deprecated()
            static class Ugly {

                static int x = 0;

                public static void main(String[] args) {
                    x = +x;
                    x = ~x;
                    --x;
                    boolean b = !false;
                    x &= 2;
                    x |= 2;
                    x ^= 2;
                    x -= 2;
                    x %= 2;
                    x /= 2;
                    x *= 2;
                    x <<= 2;
                    x >>= 2;
                    x >>>= 2;
                    b = b || false;
                    b = b | false;
                    b = b & false;
                    b = b ^ false;
                    b = b != false;
                    b = x > 1;
                    b = x < 1;
                    b = x >= 1;
                    b = x <= 1;
                    x = x << 1;
                    x = x >> 1;
                    x = x >>> 1;
                    x = x - 1;
                    x = x * 1;
                    x = x % 1;
                    x = x / 1;
                }
            }

            ;

            @Deprecated()
            int[][][][] arr2 = new int[10][2][1][0];

            volatile float fff = 0x1.fffeP+127f;

            char cc = 'a';

            int[][] arr3 = { { 1, 2 }, { 3, 4 } };

            static int[] arr4[] = {};

            public static JavaConcepts t;

            static {
                arr4 = new int[][] { { 2 }, { 1 } };
            }

            {
                arr3 = new int[][] { { 2 }, { 1 } };
            }

            public enum Teste {

                asc, def
            }

            public static enum Sexo {

                m, @Deprecated
                f;

                public static enum Sexo_ implements Serializable, Cloneable {
                }

                private Sexo() {
                }
            }

            @Deprecated
            public static enum Enum {

                m(1) {

                    @Override
                    void mm() {
                    }
                }
                , f(2) {

                    void mm() {
                    }
                }
                ;

                native void nnn();

                transient int x;

                private Enum(int x) {
                    this.x = x;
                }

                abstract void mm();
            }

            strictfp double ddd() {
                return 0.0;
            }

            public <T, E> JavaConcepts(int x) {
                this.arr[0] = x;
                T val1 = null;
                E val2 = null;
                super.<T, E>check2(val1, val2);
                boolean b = true, y = false;
                abstract class X {

                    int i = 0;

                    public <D> X() {
                    }

                    public void m() {
                    }
                }
                @Deprecated
                final class Y extends X {

                    public Y() {
                        super();
                        JavaConcepts.this.cc = 'c';
                        super.i = 1;
                        Y.super.m();
                    }

                    public Y(int y) {
                        super();
                    }

                    public Y(long x) {
                        this();
                    }
                }
            }

            public <T> JavaConcepts(String str) {
            }

            private class QWE extends JavaConcepts<List<int[]>, String> {

                @Deprecated
                final int z = 0;

                int i = (int) -1;

                public QWE(String... x) {
                    <String>super(x[0]);
                }

                public QWE(int... x) {
                    super(x[0]);
                    i = x[0];
                    assert true;
                    assert 1 == 1 : 2;
                    {
                        int iii = 3;
                        iii += 3;
                    }
                    label: {
                        int iii = 1;
                    }
                    ;
                    ;
                    int min = -2147483648;
                    long sl = 123123123123l;
                    long minl = -9223372036854775808L;
                    switch(i) {
                    }
                    ll: switch(i) {
                        case 1:
                            System.out.println(1);
                            break ll;
                        default:
                            {
                                System.out.println("default");
                                break;
                            }
                        case 2:
                            if (t instanceof Base) {
                                System.out.println(1);
                            }
                            i++;
                            ++i;
                    }
                }

                private synchronized int doSomething()[] {
                    List<? extends Number> x = new ArrayList<Integer>();
                    return new int[] { 1 };
                }
            }

            public static void main(String[] args) throws ParseException, IOException {
                int x = 2;
                CompilationUnit cu = parse(new File("src/japa/parser/javacc/Parser.java"));
                System.out.println(cu);
                JavaConcepts teste = new JavaConcepts(2);
                JavaConcepts.QWE qwe = teste.new QWE(1);
                if (1 + 1 == 2) {
                    teste = null;
                    teste = new JavaConcepts(1);
                } else {
                    x = 3;
                    teste = new JavaConcepts(1);
                    x = x == 0 ? 2 : 4;
                }
                if (true)
                    x = 1;
                else
                    x = 3;
                if (true)
                    x = 1;
                else if (false)
                    x = 3;
                else
                    x = 2;
                while (true) {
                    xxx: while (x == 3) continue xxx;
                    break;
                }
                do {
                    x++;
                } while (x < 100);
                do x++; while (x < 100);
                for (@Deprecated int i : arr4[0]) {
                    x--;
                }
                for (@Deprecated final int i = 0, j = 1; i < 10; x++) {
                    break;
                }
                int i, j;
                for (i = 0, j = 1; i < 10 && j < 2; i++, j--) {
                    break;
                }
            }

            public static CompilationUnit parse(@Deprecated File file) throws ParseException, IOException {
                String a = ((String) "qwe");
                String x = ((String) clz1.getName());
                int y = ((Integer) (Object) x).intValue();
                synchronized (file) {
                    file = null;
                    file = new File("");
                }
                try {
                    if (file == null) {
                        throw new NullPointerException("blah");
                    }
                } catch (final NullPointerException e) {
                    System.out.println("catch");
                } catch (RuntimeException e) {
                    System.out.println("catch");
                } finally {
                    System.out.println("finally");
                }
                try {
                    if (file == null) {
                        throw new NullPointerException("blah");
                    }
                } finally {
                    System.out.println("finally");
                }
                try {
                    if (file == null) {
                        throw new NullPointerException("blah");
                    }
                } catch (RuntimeException e) {
                    System.out.println("catch");
                }
                try (InputStream in = createInputStream()) {
                    System.out.println(in);
                } catch (IOException e) {
                    System.out.println("catch");
                }
                try (InputStream in = createInputStream();
                    InputStream in2 = createInputStream()) {
                    System.out.println(in);
                } catch (IOException e) {
                    System.out.println("catch");
                }
                try (InputStream in = createInputStream()) {
                    System.out.println(in);
                }
                try {
                    System.out.println("whatever");
                } catch (RuntimeException e) {
                    System.out.println(e);
                } catch (final Exception | Error e) {
                    System.out.println(e);
                }
                return JavaParser.parse(file);
            }

            class A<T extends Integer & Serializable> implements XXX, Serializable {

                public <ABC> A(Integer integer, ABC string) throws Exception, IOException {
                }
            }

            private <Y> void x(Map<? extends X, ? super T> x) {
                @Deprecated Comparator c = new Comparator() {

                    public int compare(Object o1, Object o2) {
                        try {
                            A<Integer> a = new <String>A<Integer>(new Integer(11), "foo") {
                            };
                        } catch (Exception e) {
                        }
                        return 0;
                    }

                    @Override
                    public boolean equals(Object obj) {
                        return super.equals(obj);
                    }
                };
            }

            private static InputStream createInputStream() {
                return new ByteArrayInputStream(null);
            }
        }

        class Base {

            public <A, B> void check2(A val1, B val2) {
            }
        }

        interface XXX extends Serializable, Cloneable {
        }

      */});
      assert.deepEqual(
        JavaParser.parse(src)
        ,
        {
            node: "CompilationUnit",
            package: {
                node: "PackageDeclaration",
                annotations: [],
                name: {
                    node: "QualifiedName",
                    qualifier: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "SimpleName",
                            identifier: "japa"
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "bdd"
                        }
                    },
                    name: {
                        node: "SimpleName",
                        identifier: "samples"
                    }
                }
            },
            imports: [
                {
                    node: "ImportDeclaration",
                    static: false,
                    name: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "QualifiedName",
                            qualifier: {
                                node: "QualifiedName",
                                qualifier: {
                                    node: "SimpleName",
                                    identifier: "com"
                                },
                                name: {
                                    node: "SimpleName",
                                    identifier: "github"
                                }
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "javaparser"
                            }
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "JavaParser"
                        }
                    },
                    onDemand: false
                },
                {
                    node: "ImportDeclaration",
                    static: false,
                    name: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "QualifiedName",
                            qualifier: {
                                node: "SimpleName",
                                identifier: "japa"
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "parser"
                            }
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "ParseException"
                        }
                    },
                    onDemand: false
                },
                {
                    node: "ImportDeclaration",
                    static: false,
                    name: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "QualifiedName",
                            qualifier: {
                                node: "QualifiedName",
                                qualifier: {
                                    node: "QualifiedName",
                                    qualifier: {
                                        node: "SimpleName",
                                        identifier: "com"
                                    },
                                    name: {
                                        node: "SimpleName",
                                        identifier: "github"
                                    }
                                },
                                name: {
                                    node: "SimpleName",
                                    identifier: "javaparser"
                                }
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "ast"
                            }
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "CompilationUnit"
                        }
                    },
                    onDemand: false
                },
                {
                    node: "ImportDeclaration",
                    static: false,
                    name: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "QualifiedName",
                            qualifier: {
                                node: "SimpleName",
                                identifier: "org"
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "junit"
                            }
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "Ignore"
                        }
                    },
                    onDemand: false
                },
                {
                    node: "ImportDeclaration",
                    static: false,
                    name: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "SimpleName",
                            identifier: "java"
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "io"
                        }
                    },
                    onDemand: true
                },
                {
                    node: "ImportDeclaration",
                    static: false,
                    name: {
                        node: "QualifiedName",
                        qualifier: {
                            node: "SimpleName",
                            identifier: "java"
                        },
                        name: {
                            node: "SimpleName",
                            identifier: "util"
                        }
                    },
                    onDemand: true
                }
            ],
            types: [
                {
                    node: "TypeDeclaration",
                    modifiers: [
                        {
                            node: "MarkerAnnotation",
                            typeName: {
                                node: "SimpleName",
                                identifier: "Ignore"
                            }
                        },
                        {
                            node: "MarkerAnnotation",
                            typeName: {
                                node: "SimpleName",
                                identifier: "Deprecated"
                            }
                        },
                        {
                            node: "Modifier",
                            keyword: "public"
                        }
                    ],
                    interface: false,
                    name: {
                        node: "SimpleName",
                        identifier: "JavaConcepts"
                    },
                    typeParameters: [
                        {
                            node: "TypeParameter",
                            name: {
                                node: "SimpleName",
                                identifier: "T"
                            },
                            typeBounds: [
                                {
                                    node: "ParameterizedType",
                                    type: {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "List"
                                        }
                                    },
                                    typeArguments: [
                                        {
                                            node: "ArrayType",
                                            componentType: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            }
                                        }
                                    ]
                                }
                            ]
                        },
                        {
                            node: "TypeParameter",
                            name: {
                                node: "SimpleName",
                                identifier: "X"
                            },
                            typeBounds: []
                        }
                    ],
                    superclassType: {
                        node: "SimpleType",
                        name: {
                            node: "SimpleName",
                            identifier: "Base"
                        }
                    },
                    superInterfaceTypes: [
                        {
                            node: "SimpleType",
                            name: {
                                node: "SimpleName",
                                identifier: "Serializable"
                            }
                        }
                    ],
                    bodyDeclarations: [
                        {
                            node: "FieldDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            type: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "Class"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "clz1"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "TypeLiteral",
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "String"
                                            }
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "protected"
                                }
                            ],
                            type: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "Class"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "clz2"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "ParenthesizedExpression",
                                        expression: {
                                            node: "TypeLiteral",
                                            type: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "String"
                                                }
                                            }
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "Class"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "clz3"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "TypeLiteral",
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "int"
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "Class"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "clz4"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "ParenthesizedExpression",
                                        expression: {
                                            node: "TypeLiteral",
                                            type: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            }
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "ArrayType",
                                componentType: {
                                    node: "PrimitiveType",
                                    primitiveTypeCode: "int"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "arr"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "ArrayCreation",
                                        type: {
                                            node: "ArrayType",
                                            componentType: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            }
                                        },
                                        dimensions: [
                                            {
                                                node: "NumberLiteral",
                                                token: "10"
                                            }
                                        ],
                                        initializer: null
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "byte"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "bye"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "0"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "byte"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "byebye"
                                    },
                                    extraDimensions: 1,
                                    initializer: {
                                        node: "NullLiteral"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "short"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "sh1"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                },
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "sh2"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "int"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "intWithUnderscore"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1234_5678"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "long"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "longWithUnderscore"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1234_5678L"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "float"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "floatWithUnderscore"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1_234.5_678f"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "float"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "floatWithUnderscoreAndExponent"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1_234e1_0f"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "double"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "doubleWithUnderscore"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1_234.5_678"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "double"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "doubleWithUnderscoreAndExponent"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "1_234e1_0"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "int"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "binaryLiteral"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "0b101101"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "ArrayType",
                                componentType: {
                                    node: "ArrayType",
                                    componentType: {
                                        node: "ParameterizedType",
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "List"
                                            }
                                        },
                                        typeArguments: [
                                            {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "String"
                                                }
                                            }
                                        ]
                                    }
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "arrLS"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "CastExpression",
                                        type: {
                                            node: "ArrayType",
                                            componentType: {
                                                node: "ArrayType",
                                                componentType: {
                                                    node: "ParameterizedType",
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "List"
                                                        }
                                                    },
                                                    typeArguments: [
                                                        {
                                                            node: "SimpleType",
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "String"
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        },
                                        expression: {
                                            node: "ArrayCreation",
                                            type: {
                                                node: "ArrayType",
                                                componentType: {
                                                    node: "ArrayType",
                                                    componentType: {
                                                        node: "ParameterizedType",
                                                        type: {
                                                            node: "SimpleType",
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "List"
                                                            }
                                                        },
                                                        typeArguments: [
                                                            {
                                                                node: "WildcardType",
                                                                bound: null,
                                                                upperBound: true
                                                            }
                                                        ]
                                                    }
                                                }
                                            },
                                            dimensions: [
                                                {
                                                    node: "NumberLiteral",
                                                    token: "10"
                                                }
                                            ],
                                            initializer: null
                                        }
                                    }
                                }
                            ]
                        },
                        {
                            node: "Initializer",
                            modifiers: [],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "int"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "z"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "NumberLiteral",
                                                    token: "0"
                                                }
                                            },
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "y"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "NumberLiteral",
                                                    token: "0"
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "int"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "a"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "InfixExpression",
                                                    leftOperand: {
                                                        node: "ParenthesizedExpression",
                                                        expression: {
                                                            node: "SimpleName",
                                                            identifier: "z"
                                                        }
                                                    },
                                                    operator: "+",
                                                    rightOperand: {
                                                        node: "SimpleName",
                                                        identifier: "y"
                                                    },
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "ExpressionStatement",
                                        expression: {
                                            node: "Assignment",
                                            leftHandSide: {
                                                node: "SimpleName",
                                                identifier: "a"
                                            },
                                            operator: "=",
                                            rightHandSide: {
                                                node: "InfixExpression",
                                                leftOperand: {
                                                    node: "ParenthesizedExpression",
                                                    expression: {
                                                        node: "PrefixExpression",
                                                        operator: "+",
                                                        operand: {
                                                            node: "SimpleName",
                                                            identifier: "z"
                                                        }
                                                    }
                                                },
                                                operator: "+",
                                                rightOperand: {
                                                    node: "SimpleName",
                                                    identifier: "y"
                                                },
                                            }
                                        }
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "byte"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "b"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "CastExpression",
                                                    type: {
                                                        node: "PrimitiveType",
                                                        primitiveTypeCode: "byte"
                                                    },
                                                    expression: {
                                                        node: "PrefixExpression",
                                                        operator: "+",
                                                        operand: {
                                                            node: "SimpleName",
                                                            identifier: "y"
                                                        }
                                                    }
                                                }
                                            }
                                        ]
                                    }
                                ]
                            }
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "ParameterizedType",
                                type: {
                                    node: "SimpleType",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "List"
                                    }
                                },
                                typeArguments: [
                                    {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "String"
                                        }
                                    }
                                ]
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "diamond1"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "ClassInstanceCreation",
                                        expression: null,
                                        typeArguments: [],
                                        type: {
                                            node: "ParameterizedType",
                                            type: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "LinkedList"
                                                }
                                            },
                                            typeArguments: []
                                        },
                                        arguments: [],
                                        anonymousClassDeclaration: null
                                    }
                                }
                            ]
                        },
                        {
                            node: "TypeDeclaration",
                            modifiers: [
                                {
                                    node: "NormalAnnotation",
                                    typeName: {
                                        node: "SimpleName",
                                        identifier: "Deprecated"
                                    },
                                    values: []
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            interface: false,
                            name: {
                                node: "SimpleName",
                                identifier: "Ugly"
                            },
                            typeParameters: [],
                            superclassType: null,
                            superInterfaceTypes: [],
                            bodyDeclarations: [
                                {
                                    node: "FieldDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "static"
                                        }
                                    ],
                                    type: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    },
                                    fragments: [
                                        {
                                            node: "VariableDeclarationFragment",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            extraDimensions: 0,
                                            initializer: {
                                                node: "NumberLiteral",
                                                token: "0"
                                            }
                                        }
                                    ]
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "public"
                                        },
                                        {
                                            node: "Modifier",
                                            keyword: "static"
                                        }
                                    ],
                                    constructor: false,
                                    typeParameters: [],
                                    returnType2: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "void"
                                    },
                                    name: {
                                        node: "SimpleName",
                                        identifier: "main"
                                    },
                                    parameters: [
                                        {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [],
                                            type: {
                                                node: "ArrayType",
                                                componentType: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "String"
                                                    }
                                                }
                                            },
                                            varargs: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "args"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        }
                                    ],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: {
                                        node: "Block",
                                        statements: [
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "PrefixExpression",
                                                        operator: "+",
                                                        operand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        }
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "PrefixExpression",
                                                        operator: "~",
                                                        operand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        }
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "PrefixExpression",
                                                    operator: "--",
                                                    operand: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    }
                                                }
                                            },
                                            {
                                                node: "VariableDeclarationStatement",
                                                modifiers: [],
                                                type: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "boolean"
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "b"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "PrefixExpression",
                                                            operator: "!",
                                                            operand: {
                                                                node: "BooleanLiteral",
                                                                booleanValue: false
                                                            }
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "&=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "|=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "^=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "-=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "%=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "\/=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "*=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "<<=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: ">>=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: ">>>=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "b"
                                                        },
                                                        operator: "||",
                                                        rightOperand: {
                                                            node: "BooleanLiteral",
                                                            booleanValue: false
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "b"
                                                        },
                                                        operator: "|",
                                                        rightOperand: {
                                                            node: "BooleanLiteral",
                                                            booleanValue: false
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "b"
                                                        },
                                                        operator: "&",
                                                        rightOperand: {
                                                            node: "BooleanLiteral",
                                                            booleanValue: false
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "b"
                                                        },
                                                        operator: "^",
                                                        rightOperand: {
                                                            node: "BooleanLiteral",
                                                            booleanValue: false
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "b"
                                                        },
                                                        operator: "!=",
                                                        rightOperand: {
                                                            node: "BooleanLiteral",
                                                            booleanValue: false
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: ">",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "<",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: ">=",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "b"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "<=",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "<<",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: ">>",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: ">>>",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "-",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "*",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "%",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "\/",
                                                        rightOperand: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        },
                                                    }
                                                }
                                            }
                                        ]
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [
                                {
                                    node: "NormalAnnotation",
                                    typeName: {
                                        node: "SimpleName",
                                        identifier: "Deprecated"
                                    },
                                    values: []
                                }
                            ],
                            type: {
                                node: "ArrayType",
                                componentType: {
                                    node: "ArrayType",
                                    componentType: {
                                        node: "ArrayType",
                                        componentType: {
                                            node: "ArrayType",
                                            componentType: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            }
                                        }
                                    }
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "arr2"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "ArrayCreation",
                                        type: {
                                            node: "ArrayType",
                                            componentType: {
                                                node: "ArrayType",
                                                componentType: {
                                                    node: "ArrayType",
                                                    componentType: {
                                                        node: "ArrayType",
                                                        componentType: {
                                                            node: "PrimitiveType",
                                                            primitiveTypeCode: "int"
                                                        }
                                                    }
                                                }
                                            }
                                        },
                                        dimensions: [
                                            {
                                                node: "NumberLiteral",
                                                token: "10"
                                            },
                                            {
                                                node: "NumberLiteral",
                                                token: "2"
                                            },
                                            {
                                                node: "NumberLiteral",
                                                token: "1"
                                            },
                                            {
                                                node: "NumberLiteral",
                                                token: "0"
                                            }
                                        ],
                                        initializer: null
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "volatile"
                                }
                            ],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "float"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "fff"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "NumberLiteral",
                                        token: "0x1.fffeP+127f"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "char"
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "cc"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "CharacterLiteral",
                                        escapedValue: "'a'"
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [],
                            type: {
                                node: "ArrayType",
                                componentType: {
                                    node: "ArrayType",
                                    componentType: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    }
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "arr3"
                                    },
                                    extraDimensions: 0,
                                    initializer: {
                                        node: "ArrayInitializer",
                                        expressions: [
                                            {
                                                node: "ArrayInitializer",
                                                expressions: [
                                                    {
                                                        node: "NumberLiteral",
                                                        token: "1"
                                                    },
                                                    {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                ]
                                            },
                                            {
                                                node: "ArrayInitializer",
                                                expressions: [
                                                    {
                                                        node: "NumberLiteral",
                                                        token: "3"
                                                    },
                                                    {
                                                        node: "NumberLiteral",
                                                        token: "4"
                                                    }
                                                ]
                                            }
                                        ]
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            type: {
                                node: "ArrayType",
                                componentType: {
                                    node: "PrimitiveType",
                                    primitiveTypeCode: "int"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "arr4"
                                    },
                                    extraDimensions: 1,
                                    initializer: {
                                        node: "ArrayInitializer",
                                        expressions: []
                                    }
                                }
                            ]
                        },
                        {
                            node: "FieldDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            type: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "JavaConcepts"
                                }
                            },
                            fragments: [
                                {
                                    node: "VariableDeclarationFragment",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "t"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ]
                        },
                        {
                            node: "Initializer",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "ExpressionStatement",
                                        expression: {
                                            node: "Assignment",
                                            leftHandSide: {
                                                node: "SimpleName",
                                                identifier: "arr4"
                                            },
                                            operator: "=",
                                            rightHandSide: {
                                                node: "ArrayCreation",
                                                type: {
                                                    node: "ArrayType",
                                                    componentType: {
                                                        node: "ArrayType",
                                                        componentType: {
                                                            node: "PrimitiveType",
                                                            primitiveTypeCode: "int"
                                                        }
                                                    }
                                                },
                                                dimensions: [],
                                                initializer: {
                                                    node: "ArrayInitializer",
                                                    expressions: [
                                                        {
                                                            node: "ArrayInitializer",
                                                            expressions: [
                                                                {
                                                                    node: "NumberLiteral",
                                                                    token: "2"
                                                                }
                                                            ]
                                                        },
                                                        {
                                                            node: "ArrayInitializer",
                                                            expressions: [
                                                                {
                                                                    node: "NumberLiteral",
                                                                    token: "1"
                                                                }
                                                            ]
                                                        }
                                                    ]
                                                }
                                            }
                                        }
                                    }
                                ]
                            }
                        },
                        {
                            node: "Initializer",
                            modifiers: [],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "ExpressionStatement",
                                        expression: {
                                            node: "Assignment",
                                            leftHandSide: {
                                                node: "SimpleName",
                                                identifier: "arr3"
                                            },
                                            operator: "=",
                                            rightHandSide: {
                                                node: "ArrayCreation",
                                                type: {
                                                    node: "ArrayType",
                                                    componentType: {
                                                        node: "ArrayType",
                                                        componentType: {
                                                            node: "PrimitiveType",
                                                            primitiveTypeCode: "int"
                                                        }
                                                    }
                                                },
                                                dimensions: [],
                                                initializer: {
                                                    node: "ArrayInitializer",
                                                    expressions: [
                                                        {
                                                            node: "ArrayInitializer",
                                                            expressions: [
                                                                {
                                                                    node: "NumberLiteral",
                                                                    token: "2"
                                                                }
                                                            ]
                                                        },
                                                        {
                                                            node: "ArrayInitializer",
                                                            expressions: [
                                                                {
                                                                    node: "NumberLiteral",
                                                                    token: "1"
                                                                }
                                                            ]
                                                        }
                                                    ]
                                                }
                                            }
                                        }
                                    }
                                ]
                            }
                        },
                        {
                            node: "EnumDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                }
                            ],
                            name: {
                                node: "SimpleName",
                                identifier: "Teste"
                            },
                            superInterfaceTypes: [],
                            enumConstants: [
                                {
                                    node: "EnumConstantDeclaration",
                                    modifiers: [],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "asc"
                                    },
                                    arguments: [],
                                    anonymousClassDeclaration: null
                                },
                                {
                                    node: "EnumConstantDeclaration",
                                    modifiers: [],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "def"
                                    },
                                    arguments: [],
                                    anonymousClassDeclaration: null
                                }
                            ],
                            bodyDeclarations: []
                        },
                        {
                            node: "EnumDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            name: {
                                node: "SimpleName",
                                identifier: "Sexo"
                            },
                            superInterfaceTypes: [],
                            enumConstants: [
                                {
                                    node: "EnumConstantDeclaration",
                                    modifiers: [],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "m"
                                    },
                                    arguments: [],
                                    anonymousClassDeclaration: null
                                },
                                {
                                    node: "EnumConstantDeclaration",
                                    modifiers: [
                                        {
                                            node: "MarkerAnnotation",
                                            typeName: {
                                                node: "SimpleName",
                                                identifier: "Deprecated"
                                            }
                                        }
                                    ],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "f"
                                    },
                                    arguments: [],
                                    anonymousClassDeclaration: null
                                }
                            ],
                            bodyDeclarations: [
                                {
                                    node: "EnumDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "public"
                                        },
                                        {
                                            node: "Modifier",
                                            keyword: "static"
                                        }
                                    ],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "Sexo_"
                                    },
                                    superInterfaceTypes: [
                                        {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Serializable"
                                            }
                                        },
                                        {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Cloneable"
                                            }
                                        }
                                    ],
                                    enumConstants: [],
                                    bodyDeclarations: []
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "private"
                                        }
                                    ],
                                    constructor: true,
                                    typeParameters: [],
                                    returnType2: null,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "Sexo"
                                    },
                                    parameters: [],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: {
                                        node: "Block",
                                        statements: []
                                    }
                                }
                            ]
                        },
                        {
                            node: "EnumDeclaration",
                            modifiers: [
                                {
                                    node: "MarkerAnnotation",
                                    typeName: {
                                        node: "SimpleName",
                                        identifier: "Deprecated"
                                    }
                                },
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            name: {
                                node: "SimpleName",
                                identifier: "Enum"
                            },
                            superInterfaceTypes: [],
                            enumConstants: [
                                {
                                    node: "EnumConstantDeclaration",
                                    modifiers: [],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "m"
                                    },
                                    arguments: [
                                        {
                                            node: "NumberLiteral",
                                            token: "1"
                                        }
                                    ],
                                    anonymousClassDeclaration: {
                                        node: "AnonymousClassDeclaration",
                                        bodyDeclarations: [
                                            {
                                                node: "MethodDeclaration",
                                                modifiers: [
                                                    {
                                                        node: "MarkerAnnotation",
                                                        typeName: {
                                                            node: "SimpleName",
                                                            identifier: "Override"
                                                        }
                                                    }
                                                ],
                                                constructor: false,
                                                typeParameters: [],
                                                returnType2: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "void"
                                                },
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "mm"
                                                },
                                                parameters: [],
                                                extraDimensions: 0,
                                                thrownExceptions: [],
                                                body: {
                                                    node: "Block",
                                                    statements: []
                                                }
                                            }
                                        ]
                                    }
                                },
                                {
                                    node: "EnumConstantDeclaration",
                                    modifiers: [],
                                    name: {
                                        node: "SimpleName",
                                        identifier: "f"
                                    },
                                    arguments: [
                                        {
                                            node: "NumberLiteral",
                                            token: "2"
                                        }
                                    ],
                                    anonymousClassDeclaration: {
                                        node: "AnonymousClassDeclaration",
                                        bodyDeclarations: [
                                            {
                                                node: "MethodDeclaration",
                                                modifiers: [],
                                                constructor: false,
                                                typeParameters: [],
                                                returnType2: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "void"
                                                },
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "mm"
                                                },
                                                parameters: [],
                                                extraDimensions: 0,
                                                thrownExceptions: [],
                                                body: {
                                                    node: "Block",
                                                    statements: []
                                                }
                                            }
                                        ]
                                    }
                                }
                            ],
                            bodyDeclarations: [
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "native"
                                        }
                                    ],
                                    constructor: false,
                                    typeParameters: [],
                                    returnType2: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "void"
                                    },
                                    name: {
                                        node: "SimpleName",
                                        identifier: "nnn"
                                    },
                                    parameters: [],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: null
                                },
                                {
                                    node: "FieldDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "transient"
                                        }
                                    ],
                                    type: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    },
                                    fragments: [
                                        {
                                            node: "VariableDeclarationFragment",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        }
                                    ]
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "private"
                                        }
                                    ],
                                    constructor: true,
                                    typeParameters: [],
                                    returnType2: null,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "Enum"
                                    },
                                    parameters: [
                                        {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [],
                                            type: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            },
                                            varargs: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        }
                                    ],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: {
                                        node: "Block",
                                        statements: [
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "FieldAccess",
                                                        expression: {
                                                            node: "ThisExpression",
                                                            qualifier: null
                                                        },
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        }
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    }
                                                }
                                            }
                                        ]
                                    }
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "abstract"
                                        }
                                    ],
                                    constructor: false,
                                    typeParameters: [],
                                    returnType2: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "void"
                                    },
                                    name: {
                                        node: "SimpleName",
                                        identifier: "mm"
                                    },
                                    parameters: [],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: null
                                }
                            ]
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "strictfp"
                                }
                            ],
                            constructor: false,
                            typeParameters: [],
                            returnType2: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "double"
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "ddd"
                            },
                            parameters: [],
                            extraDimensions: 0,
                            thrownExceptions: [],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "ReturnStatement",
                                        expression: {
                                            node: "NumberLiteral",
                                            token: "0.0"
                                        }
                                    }
                                ]
                            }
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                }
                            ],
                            constructor: true,
                            typeParameters: [
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "T"
                                    },
                                    typeBounds: []
                                },
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "E"
                                    },
                                    typeBounds: []
                                }
                            ],
                            returnType2: null,
                            name: {
                                node: "SimpleName",
                                identifier: "JavaConcepts"
                            },
                            parameters: [
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "x"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ],
                            extraDimensions: 0,
                            thrownExceptions: [],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "ExpressionStatement",
                                        expression: {
                                            node: "Assignment",
                                            leftHandSide: {
                                                node: "ArrayAccess",
                                                array: {
                                                    node: "FieldAccess",
                                                    expression: {
                                                        node: "ThisExpression",
                                                        qualifier: null
                                                    },
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "arr"
                                                    }
                                                },
                                                index: {
                                                    node: "NumberLiteral",
                                                    token: "0"
                                                }
                                            },
                                            operator: "=",
                                            rightHandSide: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            }
                                        }
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "T"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "val1"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "NullLiteral"
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "E"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "val2"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "NullLiteral"
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "ExpressionStatement",
                                        expression: {
                                            node: "SuperMethodInvocation",
                                            qualifier: null,
                                            typeArguments: [
                                                {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "T"
                                                    }
                                                },
                                                {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "E"
                                                    }
                                                }
                                            ],
                                            name: {
                                                node: "SimpleName",
                                                identifier: "check2"
                                            },
                                            arguments: [
                                                {
                                                    node: "SimpleName",
                                                    identifier: "val1"
                                                },
                                                {
                                                    node: "SimpleName",
                                                    identifier: "val2"
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "boolean"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "b"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "BooleanLiteral",
                                                    booleanValue: true
                                                }
                                            },
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "y"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "BooleanLiteral",
                                                    booleanValue: false
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "TypeDeclarationStatement",
                                        declaration: {
                                            node: "TypeDeclaration",
                                            modifiers: [
                                                {
                                                    node: "Modifier",
                                                    keyword: "abstract"
                                                }
                                            ],
                                            interface: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "X"
                                            },
                                            typeParameters: [],
                                            superclassType: null,
                                            superInterfaceTypes: [],
                                            bodyDeclarations: [
                                                {
                                                    node: "FieldDeclaration",
                                                    modifiers: [],
                                                    type: {
                                                        node: "PrimitiveType",
                                                        primitiveTypeCode: "int"
                                                    },
                                                    fragments: [
                                                        {
                                                            node: "VariableDeclarationFragment",
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "i"
                                                            },
                                                            extraDimensions: 0,
                                                            initializer: {
                                                                node: "NumberLiteral",
                                                                token: "0"
                                                            }
                                                        }
                                                    ]
                                                },
                                                {
                                                    node: "MethodDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "public"
                                                        }
                                                    ],
                                                    constructor: true,
                                                    typeParameters: [
                                                        {
                                                            node: "TypeParameter",
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "D"
                                                            },
                                                            typeBounds: []
                                                        }
                                                    ],
                                                    returnType2: null,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "X"
                                                    },
                                                    parameters: [],
                                                    extraDimensions: 0,
                                                    thrownExceptions: [],
                                                    body: {
                                                        node: "Block",
                                                        statements: []
                                                    }
                                                },
                                                {
                                                    node: "MethodDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "public"
                                                        }
                                                    ],
                                                    constructor: false,
                                                    typeParameters: [],
                                                    returnType2: {
                                                        node: "PrimitiveType",
                                                        primitiveTypeCode: "void"
                                                    },
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "m"
                                                    },
                                                    parameters: [],
                                                    extraDimensions: 0,
                                                    thrownExceptions: [],
                                                    body: {
                                                        node: "Block",
                                                        statements: []
                                                    }
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "TypeDeclarationStatement",
                                        declaration: {
                                            node: "TypeDeclaration",
                                            modifiers: [
                                                {
                                                    node: "MarkerAnnotation",
                                                    typeName: {
                                                        node: "SimpleName",
                                                        identifier: "Deprecated"
                                                    }
                                                },
                                                {
                                                    node: "Modifier",
                                                    keyword: "final"
                                                }
                                            ],
                                            interface: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Y"
                                            },
                                            typeParameters: [],
                                            superclassType: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "X"
                                                }
                                            },
                                            superInterfaceTypes: [],
                                            bodyDeclarations: [
                                                {
                                                    node: "MethodDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "public"
                                                        }
                                                    ],
                                                    constructor: true,
                                                    typeParameters: [],
                                                    returnType2: null,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "Y"
                                                    },
                                                    parameters: [],
                                                    extraDimensions: 0,
                                                    thrownExceptions: [],
                                                    body: {
                                                        node: "Block",
                                                        statements: [
                                                            {
                                                                node: "SuperConstructorInvocation",
                                                                expression: null,
                                                                typeArguments: [],
                                                                arguments: []
                                                            },
                                                            {
                                                                node: "ExpressionStatement",
                                                                expression: {
                                                                    node: "Assignment",
                                                                    leftHandSide: {
                                                                        node: "FieldAccess",
                                                                        expression: {
                                                                            node: "ThisExpression",
                                                                            qualifier: {
                                                                                node: "SimpleName",
                                                                                identifier: "JavaConcepts"
                                                                            }
                                                                        },
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "cc"
                                                                        }
                                                                    },
                                                                    operator: "=",
                                                                    rightHandSide: {
                                                                        node: "CharacterLiteral",
                                                                        escapedValue: "'c'"
                                                                    }
                                                                }
                                                            },
                                                            {
                                                                node: "ExpressionStatement",
                                                                expression: {
                                                                    node: "Assignment",
                                                                    leftHandSide: {
                                                                        node: "SuperFieldAccess",
                                                                        qualifier: null,
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "i"
                                                                        }
                                                                    },
                                                                    operator: "=",
                                                                    rightHandSide: {
                                                                        node: "NumberLiteral",
                                                                        token: "1"
                                                                    }
                                                                }
                                                            },
                                                            {
                                                                node: "ExpressionStatement",
                                                                expression: {
                                                                    node: "SuperMethodInvocation",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "Y"
                                                                    },
                                                                    typeArguments: [],
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "m"
                                                                    },
                                                                    arguments: []
                                                                }
                                                            }
                                                        ]
                                                    }
                                                },
                                                {
                                                    node: "MethodDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "public"
                                                        }
                                                    ],
                                                    constructor: true,
                                                    typeParameters: [],
                                                    returnType2: null,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "Y"
                                                    },
                                                    parameters: [
                                                        {
                                                            node: "SingleVariableDeclaration",
                                                            modifiers: [],
                                                            type: {
                                                                node: "PrimitiveType",
                                                                primitiveTypeCode: "int"
                                                            },
                                                            varargs: false,
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "y"
                                                            },
                                                            extraDimensions: 0,
                                                            initializer: null
                                                        }
                                                    ],
                                                    extraDimensions: 0,
                                                    thrownExceptions: [],
                                                    body: {
                                                        node: "Block",
                                                        statements: [
                                                            {
                                                                node: "SuperConstructorInvocation",
                                                                expression: null,
                                                                typeArguments: [],
                                                                arguments: []
                                                            }
                                                        ]
                                                    }
                                                },
                                                {
                                                    node: "MethodDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "public"
                                                        }
                                                    ],
                                                    constructor: true,
                                                    typeParameters: [],
                                                    returnType2: null,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "Y"
                                                    },
                                                    parameters: [
                                                        {
                                                            node: "SingleVariableDeclaration",
                                                            modifiers: [],
                                                            type: {
                                                                node: "PrimitiveType",
                                                                primitiveTypeCode: "long"
                                                            },
                                                            varargs: false,
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "x"
                                                            },
                                                            extraDimensions: 0,
                                                            initializer: null
                                                        }
                                                    ],
                                                    extraDimensions: 0,
                                                    thrownExceptions: [],
                                                    body: {
                                                        node: "Block",
                                                        statements: [
                                                            {
                                                                node: "ConstructorInvocation",
                                                                typeArguments: [],
                                                                arguments: []
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        }
                                    }
                                ]
                            }
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                }
                            ],
                            constructor: true,
                            typeParameters: [
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "T"
                                    },
                                    typeBounds: []
                                }
                            ],
                            returnType2: null,
                            name: {
                                node: "SimpleName",
                                identifier: "JavaConcepts"
                            },
                            parameters: [
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "String"
                                        }
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "str"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ],
                            extraDimensions: 0,
                            thrownExceptions: [],
                            body: {
                                node: "Block",
                                statements: []
                            }
                        },
                        {
                            node: "TypeDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "private"
                                }
                            ],
                            interface: false,
                            name: {
                                node: "SimpleName",
                                identifier: "QWE"
                            },
                            typeParameters: [],
                            superclassType: {
                                node: "ParameterizedType",
                                type: {
                                    node: "SimpleType",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "JavaConcepts"
                                    }
                                },
                                typeArguments: [
                                    {
                                        node: "ParameterizedType",
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "List"
                                            }
                                        },
                                        typeArguments: [
                                            {
                                                node: "ArrayType",
                                                componentType: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "int"
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "String"
                                        }
                                    }
                                ]
                            },
                            superInterfaceTypes: [],
                            bodyDeclarations: [
                                {
                                    node: "FieldDeclaration",
                                    modifiers: [
                                        {
                                            node: "MarkerAnnotation",
                                            typeName: {
                                                node: "SimpleName",
                                                identifier: "Deprecated"
                                            }
                                        },
                                        {
                                            node: "Modifier",
                                            keyword: "final"
                                        }
                                    ],
                                    type: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    },
                                    fragments: [
                                        {
                                            node: "VariableDeclarationFragment",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "z"
                                            },
                                            extraDimensions: 0,
                                            initializer: {
                                                node: "NumberLiteral",
                                                token: "0"
                                            }
                                        }
                                    ]
                                },
                                {
                                    node: "FieldDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    },
                                    fragments: [
                                        {
                                            node: "VariableDeclarationFragment",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "i"
                                            },
                                            extraDimensions: 0,
                                            initializer: {
                                                node: "CastExpression",
                                                type: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "int"
                                                },
                                                expression: {
                                                    node: "PrefixExpression",
                                                    operator: "-",
                                                    operand: {
                                                        node: "NumberLiteral",
                                                        token: "1"
                                                    }
                                                }
                                            }
                                        }
                                    ]
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "public"
                                        }
                                    ],
                                    constructor: true,
                                    typeParameters: [],
                                    returnType2: null,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "QWE"
                                    },
                                    parameters: [
                                        {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [],
                                            type: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "String"
                                                }
                                            },
                                            varargs: true,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        }
                                    ],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: {
                                        node: "Block",
                                        statements: [
                                            {
                                                node: "SuperConstructorInvocation",
                                                expression: null,
                                                typeArguments: [
                                                    {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "String"
                                                        }
                                                    }
                                                ],
                                                arguments: [
                                                    {
                                                        node: "ArrayAccess",
                                                        array: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        index: {
                                                            node: "NumberLiteral",
                                                            token: "0"
                                                        }
                                                    }
                                                ]
                                            }
                                        ]
                                    }
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "public"
                                        }
                                    ],
                                    constructor: true,
                                    typeParameters: [],
                                    returnType2: null,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "QWE"
                                    },
                                    parameters: [
                                        {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [],
                                            type: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            },
                                            varargs: true,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        }
                                    ],
                                    extraDimensions: 0,
                                    thrownExceptions: [],
                                    body: {
                                        node: "Block",
                                        statements: [
                                            {
                                                node: "SuperConstructorInvocation",
                                                expression: null,
                                                typeArguments: [],
                                                arguments: [
                                                    {
                                                        node: "ArrayAccess",
                                                        array: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        index: {
                                                            node: "NumberLiteral",
                                                            token: "0"
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "i"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "ArrayAccess",
                                                        array: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        index: {
                                                            node: "NumberLiteral",
                                                            token: "0"
                                                        }
                                                    }
                                                }
                                            },
                                            {
                                                node: "AssertStatement",
                                                expression: {
                                                    node: "BooleanLiteral",
                                                    booleanValue: true
                                                },
                                                message: null
                                            },
                                            {
                                                node: "AssertStatement",
                                                expression: {
                                                    node: "InfixExpression",
                                                    leftOperand: {
                                                        node: "NumberLiteral",
                                                        token: "1"
                                                    },
                                                    operator: "==",
                                                    rightOperand: {
                                                        node: "NumberLiteral",
                                                        token: "1"
                                                    },
                                                },
                                                message: {
                                                    node: "NumberLiteral",
                                                    token: "2"
                                                }
                                            },
                                            {
                                                node: "Block",
                                                statements: [
                                                    {
                                                        node: "VariableDeclarationStatement",
                                                        modifiers: [],
                                                        type: {
                                                            node: "PrimitiveType",
                                                            primitiveTypeCode: "int"
                                                        },
                                                        fragments: [
                                                            {
                                                                node: "VariableDeclarationFragment",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "iii"
                                                                },
                                                                extraDimensions: 0,
                                                                initializer: {
                                                                    node: "NumberLiteral",
                                                                    token: "3"
                                                                }
                                                            }
                                                        ]
                                                    },
                                                    {
                                                        node: "ExpressionStatement",
                                                        expression: {
                                                            node: "Assignment",
                                                            leftHandSide: {
                                                                node: "SimpleName",
                                                                identifier: "iii"
                                                            },
                                                            operator: "+=",
                                                            rightHandSide: {
                                                                node: "NumberLiteral",
                                                                token: "3"
                                                            }
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "LabeledStatement",
                                                label: {
                                                    node: "SimpleName",
                                                    identifier: "label"
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "VariableDeclarationStatement",
                                                            modifiers: [],
                                                            type: {
                                                                node: "PrimitiveType",
                                                                primitiveTypeCode: "int"
                                                            },
                                                            fragments: [
                                                                {
                                                                    node: "VariableDeclarationFragment",
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "iii"
                                                                    },
                                                                    extraDimensions: 0,
                                                                    initializer: {
                                                                        node: "NumberLiteral",
                                                                        token: "1"
                                                                    }
                                                                }
                                                            ]
                                                        }
                                                    ]
                                                }
                                            },
                                            {
                                                node: "EmptyStatement"
                                            },
                                            {
                                                node: "EmptyStatement"
                                            },
                                            {
                                                node: "VariableDeclarationStatement",
                                                modifiers: [],
                                                type: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "int"
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "min"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "NumberLiteral",
                                                            token: "-2147483648"
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "VariableDeclarationStatement",
                                                modifiers: [],
                                                type: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "long"
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "sl"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "NumberLiteral",
                                                            token: "123123123123l"
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "VariableDeclarationStatement",
                                                modifiers: [],
                                                type: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "long"
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "minl"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "NumberLiteral",
                                                            token: "-9223372036854775808L"
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "SwitchStatement",
                                                expression: {
                                                    node: "SimpleName",
                                                    identifier: "i"
                                                },
                                                statements: []
                                            },
                                            {
                                                node: "LabeledStatement",
                                                label: {
                                                    node: "SimpleName",
                                                    identifier: "ll"
                                                },
                                                body: {
                                                    node: "SwitchStatement",
                                                    expression: {
                                                        node: "SimpleName",
                                                        identifier: "i"
                                                    },
                                                    statements: [
                                                        {
                                                            node: "SwitchCase",
                                                            expression: {
                                                                node: "NumberLiteral",
                                                                token: "1"
                                                            }
                                                        },
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "NumberLiteral",
                                                                        token: "1"
                                                                    }
                                                                ]
                                                            }
                                                        },
                                                        {
                                                            node: "BreakStatement",
                                                            label: {
                                                                node: "SimpleName",
                                                                identifier: "ll"
                                                            }
                                                        },
                                                        {
                                                            node: "SwitchCase",
                                                            expression: null
                                                        },
                                                        {
                                                            node: "Block",
                                                            statements: [
                                                                {
                                                                    node: "ExpressionStatement",
                                                                    expression: {
                                                                        node: "MethodInvocation",
                                                                        expression: {
                                                                            node: "QualifiedName",
                                                                            qualifier: {
                                                                                node: "SimpleName",
                                                                                identifier: "System"
                                                                            },
                                                                            name: {
                                                                                node: "SimpleName",
                                                                                identifier: "out"
                                                                            }
                                                                        },
                                                                        typeArguments: [],
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "println"
                                                                        },
                                                                        arguments: [
                                                                            {
                                                                                node: "StringLiteral",
                                                                                escapedValue: "\"default\""
                                                                            }
                                                                        ]
                                                                    }
                                                                },
                                                                {
                                                                    node: "BreakStatement",
                                                                    label: null
                                                                }
                                                            ]
                                                        },
                                                        {
                                                            node: "SwitchCase",
                                                            expression: {
                                                                node: "NumberLiteral",
                                                                token: "2"
                                                            }
                                                        },
                                                        {
                                                            node: "IfStatement",
                                                            expression: {
                                                                node: "InstanceofExpression",
                                                                leftOperand: {
                                                                    node: "SimpleName",
                                                                    identifier: "t"
                                                                },
                                                                rightOperand: {
                                                                    node: "SimpleType",
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "Base"
                                                                    }
                                                                }
                                                            },
                                                            thenStatement: {
                                                                node: "Block",
                                                                statements: [
                                                                    {
                                                                        node: "ExpressionStatement",
                                                                        expression: {
                                                                            node: "MethodInvocation",
                                                                            expression: {
                                                                                node: "QualifiedName",
                                                                                qualifier: {
                                                                                    node: "SimpleName",
                                                                                    identifier: "System"
                                                                                },
                                                                                name: {
                                                                                    node: "SimpleName",
                                                                                    identifier: "out"
                                                                                }
                                                                            },
                                                                            typeArguments: [],
                                                                            name: {
                                                                                node: "SimpleName",
                                                                                identifier: "println"
                                                                            },
                                                                            arguments: [
                                                                                {
                                                                                    node: "NumberLiteral",
                                                                                    token: "1"
                                                                                }
                                                                            ]
                                                                        }
                                                                    }
                                                                ]
                                                            },
                                                            elseStatement: null
                                                        },
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "PostfixExpression",
                                                                operand: {
                                                                    node: "SimpleName",
                                                                    identifier: "i"
                                                                },
                                                                operator: "++"
                                                            }
                                                        },
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "PrefixExpression",
                                                                operator: "++",
                                                                operand: {
                                                                    node: "SimpleName",
                                                                    identifier: "i"
                                                                }
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        ]
                                    }
                                },
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "private"
                                        },
                                        {
                                            node: "Modifier",
                                            keyword: "synchronized"
                                        }
                                    ],
                                    constructor: false,
                                    typeParameters: [],
                                    returnType2: {
                                        node: "PrimitiveType",
                                        primitiveTypeCode: "int"
                                    },
                                    name: {
                                        node: "SimpleName",
                                        identifier: "doSomething"
                                    },
                                    parameters: [],
                                    extraDimensions: 1,
                                    thrownExceptions: [],
                                    body: {
                                        node: "Block",
                                        statements: [
                                            {
                                                node: "VariableDeclarationStatement",
                                                modifiers: [],
                                                type: {
                                                    node: "ParameterizedType",
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "List"
                                                        }
                                                    },
                                                    typeArguments: [
                                                        {
                                                            node: "WildcardType",
                                                            bound: {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "Number"
                                                                }
                                                            },
                                                            upperBound: true
                                                        }
                                                    ]
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "ClassInstanceCreation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            type: {
                                                                node: "ParameterizedType",
                                                                type: {
                                                                    node: "SimpleType",
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "ArrayList"
                                                                    }
                                                                },
                                                                typeArguments: [
                                                                    {
                                                                        node: "SimpleType",
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "Integer"
                                                                        }
                                                                    }
                                                                ]
                                                            },
                                                            arguments: [],
                                                            anonymousClassDeclaration: null
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "ReturnStatement",
                                                expression: {
                                                    node: "ArrayCreation",
                                                    type: {
                                                        node: "ArrayType",
                                                        componentType: {
                                                            node: "PrimitiveType",
                                                            primitiveTypeCode: "int"
                                                        }
                                                    },
                                                    dimensions: [],
                                                    initializer: {
                                                        node: "ArrayInitializer",
                                                        expressions: [
                                                            {
                                                                node: "NumberLiteral",
                                                                token: "1"
                                                            }
                                                        ]
                                                    }
                                                }
                                            }
                                        ]
                                    }
                                }
                            ]
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            constructor: false,
                            typeParameters: [],
                            returnType2: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "void"
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "main"
                            },
                            parameters: [
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "ArrayType",
                                        componentType: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "String"
                                            }
                                        }
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "args"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ],
                            extraDimensions: 0,
                            thrownExceptions: [
                                {
                                    node: "SimpleName",
                                    identifier: "ParseException"
                                },
                                {
                                    node: "SimpleName",
                                    identifier: "IOException"
                                }
                            ],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "int"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "NumberLiteral",
                                                    token: "2"
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "CompilationUnit"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "cu"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "MethodInvocation",
                                                    expression: null,
                                                    typeArguments: [],
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "parse"
                                                    },
                                                    arguments: [
                                                        {
                                                            node: "ClassInstanceCreation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            type: {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "File"
                                                                }
                                                            },
                                                            arguments: [
                                                                {
                                                                    node: "StringLiteral",
                                                                    escapedValue: "\"src\/japa\/parser\/javacc\/Parser.java\""
                                                                }
                                                            ],
                                                            anonymousClassDeclaration: null
                                                        }
                                                    ]
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "ExpressionStatement",
                                        expression: {
                                            node: "MethodInvocation",
                                            expression: {
                                                node: "QualifiedName",
                                                qualifier: {
                                                    node: "SimpleName",
                                                    identifier: "System"
                                                },
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "out"
                                                }
                                            },
                                            typeArguments: [],
                                            name: {
                                                node: "SimpleName",
                                                identifier: "println"
                                            },
                                            arguments: [
                                                {
                                                    node: "SimpleName",
                                                    identifier: "cu"
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "JavaConcepts"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "teste"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "ClassInstanceCreation",
                                                    expression: null,
                                                    typeArguments: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "JavaConcepts"
                                                        }
                                                    },
                                                    arguments: [
                                                        {
                                                            node: "NumberLiteral",
                                                            token: "2"
                                                        }
                                                    ],
                                                    anonymousClassDeclaration: null
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "QualifiedName",
                                                qualifier: {
                                                    node: "SimpleName",
                                                    identifier: "JavaConcepts"
                                                },
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "QWE"
                                                }
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "qwe"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "ClassInstanceCreation",
                                                    expression: {
                                                        node: "SimpleName",
                                                        identifier: "teste"
                                                    },
                                                    typeArguments: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "QWE"
                                                        }
                                                    },
                                                    arguments: [
                                                        {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        }
                                                    ],
                                                    anonymousClassDeclaration: null
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "IfStatement",
                                        expression: {
                                            node: "InfixExpression",
                                            leftOperand: {
                                                node: "InfixExpression",
                                                leftOperand: {
                                                    node: "NumberLiteral",
                                                    token: "1"
                                                },
                                                operator: "+",
                                                rightOperand: {
                                                    node: "NumberLiteral",
                                                    token: "1"
                                                },
                                            },
                                            operator: "==",
                                            rightOperand: {
                                                node: "NumberLiteral",
                                                token: "2"
                                            },
                                        },
                                        thenStatement: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "teste"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "NullLiteral"
                                                        }
                                                    }
                                                },
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "teste"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "ClassInstanceCreation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            type: {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "JavaConcepts"
                                                                }
                                                            },
                                                            arguments: [
                                                                {
                                                                    node: "NumberLiteral",
                                                                    token: "1"
                                                                }
                                                            ],
                                                            anonymousClassDeclaration: null
                                                        }
                                                    }
                                                }
                                            ]
                                        },
                                        elseStatement: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "NumberLiteral",
                                                            token: "3"
                                                        }
                                                    }
                                                },
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "teste"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "ClassInstanceCreation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            type: {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "JavaConcepts"
                                                                }
                                                            },
                                                            arguments: [
                                                                {
                                                                    node: "NumberLiteral",
                                                                    token: "1"
                                                                }
                                                            ],
                                                            anonymousClassDeclaration: null
                                                        }
                                                    }
                                                },
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "ConditionalExpression",
                                                            expression: {
                                                                node: "InfixExpression",
                                                                leftOperand: {
                                                                    node: "SimpleName",
                                                                    identifier: "x"
                                                                },
                                                                operator: "==",
                                                                rightOperand: {
                                                                    node: "NumberLiteral",
                                                                    token: "0"
                                                                },
                                                            },
                                                            thenExpression: {
                                                                node: "NumberLiteral",
                                                                token: "2"
                                                            },
                                                            elseExpression: {
                                                                node: "NumberLiteral",
                                                                token: "4"
                                                            }
                                                        }
                                                    }
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "IfStatement",
                                        expression: {
                                            node: "BooleanLiteral",
                                            booleanValue: true
                                        },
                                        thenStatement: {
                                            node: "ExpressionStatement",
                                            expression: {
                                                node: "Assignment",
                                                leftHandSide: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                operator: "=",
                                                rightHandSide: {
                                                    node: "NumberLiteral",
                                                    token: "1"
                                                }
                                            }
                                        },
                                        elseStatement: {
                                            node: "ExpressionStatement",
                                            expression: {
                                                node: "Assignment",
                                                leftHandSide: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                operator: "=",
                                                rightHandSide: {
                                                    node: "NumberLiteral",
                                                    token: "3"
                                                }
                                            }
                                        }
                                    },
                                    {
                                        node: "IfStatement",
                                        expression: {
                                            node: "BooleanLiteral",
                                            booleanValue: true
                                        },
                                        thenStatement: {
                                            node: "ExpressionStatement",
                                            expression: {
                                                node: "Assignment",
                                                leftHandSide: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                operator: "=",
                                                rightHandSide: {
                                                    node: "NumberLiteral",
                                                    token: "1"
                                                }
                                            }
                                        },
                                        elseStatement: {
                                            node: "IfStatement",
                                            expression: {
                                                node: "BooleanLiteral",
                                                booleanValue: false
                                            },
                                            thenStatement: {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "3"
                                                    }
                                                }
                                            },
                                            elseStatement: {
                                                node: "ExpressionStatement",
                                                expression: {
                                                    node: "Assignment",
                                                    leftHandSide: {
                                                        node: "SimpleName",
                                                        identifier: "x"
                                                    },
                                                    operator: "=",
                                                    rightHandSide: {
                                                        node: "NumberLiteral",
                                                        token: "2"
                                                    }
                                                }
                                            }
                                        }
                                    },
                                    {
                                        node: "WhileStatement",
                                        expression: {
                                            node: "BooleanLiteral",
                                            booleanValue: true
                                        },
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "LabeledStatement",
                                                    label: {
                                                        node: "SimpleName",
                                                        identifier: "xxx"
                                                    },
                                                    body: {
                                                        node: "WhileStatement",
                                                        expression: {
                                                            node: "InfixExpression",
                                                            leftOperand: {
                                                                node: "SimpleName",
                                                                identifier: "x"
                                                            },
                                                            operator: "==",
                                                            rightOperand: {
                                                                node: "NumberLiteral",
                                                                token: "3"
                                                            },
                                                        },
                                                        body: {
                                                            node: "ContinueStatement",
                                                            label: {
                                                                node: "SimpleName",
                                                                identifier: "xxx"
                                                            }
                                                        }
                                                    }
                                                },
                                                {
                                                    node: "BreakStatement",
                                                    label: null
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "DoStatement",
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "PostfixExpression",
                                                        operand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "++"
                                                    }
                                                }
                                            ]
                                        },
                                        expression: {
                                            node: "InfixExpression",
                                            leftOperand: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            operator: "<",
                                            rightOperand: {
                                                node: "NumberLiteral",
                                                token: "100"
                                            },
                                        }
                                    },
                                    {
                                        node: "DoStatement",
                                        body: {
                                            node: "ExpressionStatement",
                                            expression: {
                                                node: "PostfixExpression",
                                                operand: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                operator: "++"
                                            }
                                        },
                                        expression: {
                                            node: "InfixExpression",
                                            leftOperand: {
                                                node: "SimpleName",
                                                identifier: "x"
                                            },
                                            operator: "<",
                                            rightOperand: {
                                                node: "NumberLiteral",
                                                token: "100"
                                            },
                                        }
                                    },
                                    {
                                        node: "EnhancedForStatement",
                                        parameter: {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [
                                                {
                                                    node: "MarkerAnnotation",
                                                    typeName: {
                                                        node: "SimpleName",
                                                        identifier: "Deprecated"
                                                    }
                                                }
                                            ],
                                            type: {
                                                node: "PrimitiveType",
                                                primitiveTypeCode: "int"
                                            },
                                            varargs: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "i"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        },
                                        expression: {
                                            node: "ArrayAccess",
                                            array: {
                                                node: "SimpleName",
                                                identifier: "arr4"
                                            },
                                            index: {
                                                node: "NumberLiteral",
                                                token: "0"
                                            }
                                        },
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "PostfixExpression",
                                                        operand: {
                                                            node: "SimpleName",
                                                            identifier: "x"
                                                        },
                                                        operator: "--"
                                                    }
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "ForStatement",
                                        initializers: [
                                            {
                                                node: "VariableDeclarationExpression",
                                                modifiers: [
                                                    {
                                                        node: "MarkerAnnotation",
                                                        typeName: {
                                                            node: "SimpleName",
                                                            identifier: "Deprecated"
                                                        }
                                                    },
                                                    {
                                                        node: "Modifier",
                                                        keyword: "final"
                                                    }
                                                ],
                                                type: {
                                                    node: "PrimitiveType",
                                                    primitiveTypeCode: "int"
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "i"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "NumberLiteral",
                                                            token: "0"
                                                        }
                                                    },
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "j"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "NumberLiteral",
                                                            token: "1"
                                                        }
                                                    }
                                                ]
                                            }
                                        ],
                                        expression: {
                                            node: "InfixExpression",
                                            leftOperand: {
                                                node: "SimpleName",
                                                identifier: "i"
                                            },
                                            operator: "<",
                                            rightOperand: {
                                                node: "NumberLiteral",
                                                token: "10"
                                            },
                                        },
                                        updaters: [
                                            {
                                                node: "PostfixExpression",
                                                operand: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                operator: "++"
                                            }
                                        ],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "BreakStatement",
                                                    label: null
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "int"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "i"
                                                },
                                                extraDimensions: 0,
                                                initializer: null
                                            },
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "j"
                                                },
                                                extraDimensions: 0,
                                                initializer: null
                                            }
                                        ]
                                    },
                                    {
                                        node: "ForStatement",
                                        initializers: [
                                            {
                                                node: "Assignment",
                                                leftHandSide: {
                                                    node: "SimpleName",
                                                    identifier: "i"
                                                },
                                                operator: "=",
                                                rightHandSide: {
                                                    node: "NumberLiteral",
                                                    token: "0"
                                                }
                                            },
                                            {
                                                node: "Assignment",
                                                leftHandSide: {
                                                    node: "SimpleName",
                                                    identifier: "j"
                                                },
                                                operator: "=",
                                                rightHandSide: {
                                                    node: "NumberLiteral",
                                                    token: "1"
                                                }
                                            }
                                        ],
                                        expression: {
                                            node: "InfixExpression",
                                            leftOperand: {
                                                node: "InfixExpression",
                                                leftOperand: {
                                                    node: "SimpleName",
                                                    identifier: "i"
                                                },
                                                operator: "<",
                                                rightOperand: {
                                                    node: "NumberLiteral",
                                                    token: "10"
                                                },
                                            },
                                            operator: "&&",
                                            rightOperand: {
                                                node: "InfixExpression",
                                                leftOperand: {
                                                    node: "SimpleName",
                                                    identifier: "j"
                                                },
                                                operator: "<",
                                                rightOperand: {
                                                    node: "NumberLiteral",
                                                    token: "2"
                                                },
                                            },
                                        },
                                        updaters: [
                                            {
                                                node: "PostfixExpression",
                                                operand: {
                                                    node: "SimpleName",
                                                    identifier: "i"
                                                },
                                                operator: "++"
                                            },
                                            {
                                                node: "PostfixExpression",
                                                operand: {
                                                    node: "SimpleName",
                                                    identifier: "j"
                                                },
                                                operator: "--"
                                            }
                                        ],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "BreakStatement",
                                                    label: null
                                                }
                                            ]
                                        }
                                    }
                                ]
                            }
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            constructor: false,
                            typeParameters: [],
                            returnType2: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "CompilationUnit"
                                }
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "parse"
                            },
                            parameters: [
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [
                                        {
                                            node: "MarkerAnnotation",
                                            typeName: {
                                                node: "SimpleName",
                                                identifier: "Deprecated"
                                            }
                                        }
                                    ],
                                    type: {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "File"
                                        }
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "file"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ],
                            extraDimensions: 0,
                            thrownExceptions: [
                                {
                                    node: "SimpleName",
                                    identifier: "ParseException"
                                },
                                {
                                    node: "SimpleName",
                                    identifier: "IOException"
                                }
                            ],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "String"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "a"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "ParenthesizedExpression",
                                                    expression: {
                                                        node: "CastExpression",
                                                        type: {
                                                            node: "SimpleType",
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "String"
                                                            }
                                                        },
                                                        expression: {
                                                            node: "StringLiteral",
                                                            escapedValue: "\"qwe\""
                                                        }
                                                    }
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "String"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "x"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "ParenthesizedExpression",
                                                    expression: {
                                                        node: "CastExpression",
                                                        type: {
                                                            node: "SimpleType",
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "String"
                                                            }
                                                        },
                                                        expression: {
                                                            node: "MethodInvocation",
                                                            expression: {
                                                                node: "SimpleName",
                                                                identifier: "clz1"
                                                            },
                                                            typeArguments: [],
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "getName"
                                                            },
                                                            arguments: []
                                                        }
                                                    }
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [],
                                        type: {
                                            node: "PrimitiveType",
                                            primitiveTypeCode: "int"
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "y"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "MethodInvocation",
                                                    expression: {
                                                        node: "ParenthesizedExpression",
                                                        expression: {
                                                            node: "CastExpression",
                                                            type: {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "Integer"
                                                                }
                                                            },
                                                            expression: {
                                                                node: "CastExpression",
                                                                type: {
                                                                    node: "SimpleType",
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "Object"
                                                                    }
                                                                },
                                                                expression: {
                                                                    node: "SimpleName",
                                                                    identifier: "x"
                                                                }
                                                            }
                                                        }
                                                    },
                                                    typeArguments: [],
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "intValue"
                                                    },
                                                    arguments: []
                                                }
                                            }
                                        ]
                                    },
                                    {
                                        node: "SynchronizedStatement",
                                        expression: {
                                            node: "SimpleName",
                                            identifier: "file"
                                        },
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "file"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "NullLiteral"
                                                        }
                                                    }
                                                },
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "Assignment",
                                                        leftHandSide: {
                                                            node: "SimpleName",
                                                            identifier: "file"
                                                        },
                                                        operator: "=",
                                                        rightHandSide: {
                                                            node: "ClassInstanceCreation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            type: {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "File"
                                                                }
                                                            },
                                                            arguments: [
                                                                {
                                                                    node: "StringLiteral",
                                                                    escapedValue: "\"\""
                                                                }
                                                            ],
                                                            anonymousClassDeclaration: null
                                                        }
                                                    }
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "IfStatement",
                                                    expression: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "file"
                                                        },
                                                        operator: "==",
                                                        rightOperand: {
                                                            node: "NullLiteral"
                                                        },
                                                    },
                                                    thenStatement: {
                                                        node: "Block",
                                                        statements: [
                                                            {
                                                                node: "ThrowStatement",
                                                                expression: {
                                                                    node: "ClassInstanceCreation",
                                                                    expression: null,
                                                                    typeArguments: [],
                                                                    type: {
                                                                        node: "SimpleType",
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "NullPointerException"
                                                                        }
                                                                    },
                                                                    arguments: [
                                                                        {
                                                                            node: "StringLiteral",
                                                                            escapedValue: "\"blah\""
                                                                        }
                                                                    ],
                                                                    anonymousClassDeclaration: null
                                                                }
                                                            }
                                                        ]
                                                    },
                                                    elseStatement: null
                                                }
                                            ]
                                        },
                                        catchClauses: [
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "final"
                                                        }
                                                    ],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "NullPointerException"
                                                        }
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "StringLiteral",
                                                                        escapedValue: "\"catch\""
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            },
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "RuntimeException"
                                                        }
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "StringLiteral",
                                                                        escapedValue: "\"catch\""
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        ],
                                        finally: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "MethodInvocation",
                                                        expression: {
                                                            node: "QualifiedName",
                                                            qualifier: {
                                                                node: "SimpleName",
                                                                identifier: "System"
                                                            },
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "out"
                                                            }
                                                        },
                                                        typeArguments: [],
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "println"
                                                        },
                                                        arguments: [
                                                            {
                                                                node: "StringLiteral",
                                                                escapedValue: "\"finally\""
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "IfStatement",
                                                    expression: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "file"
                                                        },
                                                        operator: "==",
                                                        rightOperand: {
                                                            node: "NullLiteral"
                                                        },
                                                    },
                                                    thenStatement: {
                                                        node: "Block",
                                                        statements: [
                                                            {
                                                                node: "ThrowStatement",
                                                                expression: {
                                                                    node: "ClassInstanceCreation",
                                                                    expression: null,
                                                                    typeArguments: [],
                                                                    type: {
                                                                        node: "SimpleType",
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "NullPointerException"
                                                                        }
                                                                    },
                                                                    arguments: [
                                                                        {
                                                                            node: "StringLiteral",
                                                                            escapedValue: "\"blah\""
                                                                        }
                                                                    ],
                                                                    anonymousClassDeclaration: null
                                                                }
                                                            }
                                                        ]
                                                    },
                                                    elseStatement: null
                                                }
                                            ]
                                        },
                                        catchClauses: [],
                                        finally: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "MethodInvocation",
                                                        expression: {
                                                            node: "QualifiedName",
                                                            qualifier: {
                                                                node: "SimpleName",
                                                                identifier: "System"
                                                            },
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "out"
                                                            }
                                                        },
                                                        typeArguments: [],
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "println"
                                                        },
                                                        arguments: [
                                                            {
                                                                node: "StringLiteral",
                                                                escapedValue: "\"finally\""
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        }
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "IfStatement",
                                                    expression: {
                                                        node: "InfixExpression",
                                                        leftOperand: {
                                                            node: "SimpleName",
                                                            identifier: "file"
                                                        },
                                                        operator: "==",
                                                        rightOperand: {
                                                            node: "NullLiteral"
                                                        },
                                                    },
                                                    thenStatement: {
                                                        node: "Block",
                                                        statements: [
                                                            {
                                                                node: "ThrowStatement",
                                                                expression: {
                                                                    node: "ClassInstanceCreation",
                                                                    expression: null,
                                                                    typeArguments: [],
                                                                    type: {
                                                                        node: "SimpleType",
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "NullPointerException"
                                                                        }
                                                                    },
                                                                    arguments: [
                                                                        {
                                                                            node: "StringLiteral",
                                                                            escapedValue: "\"blah\""
                                                                        }
                                                                    ],
                                                                    anonymousClassDeclaration: null
                                                                }
                                                            }
                                                        ]
                                                    },
                                                    elseStatement: null
                                                }
                                            ]
                                        },
                                        catchClauses: [
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "RuntimeException"
                                                        }
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "StringLiteral",
                                                                        escapedValue: "\"catch\""
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        ],
                                        finally: null
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [
                                            {
                                                node: "VariableDeclarationExpression",
                                                modifiers: [],
                                                type: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "InputStream"
                                                    }
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "in"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "MethodInvocation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "createInputStream"
                                                            },
                                                            arguments: []
                                                        }
                                                    }
                                                ]
                                            }
                                        ],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "MethodInvocation",
                                                        expression: {
                                                            node: "QualifiedName",
                                                            qualifier: {
                                                                node: "SimpleName",
                                                                identifier: "System"
                                                            },
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "out"
                                                            }
                                                        },
                                                        typeArguments: [],
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "println"
                                                        },
                                                        arguments: [
                                                            {
                                                                node: "SimpleName",
                                                                identifier: "in"
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        },
                                        catchClauses: [
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "IOException"
                                                        }
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "StringLiteral",
                                                                        escapedValue: "\"catch\""
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        ],
                                        finally: null
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [
                                            {
                                                node: "VariableDeclarationExpression",
                                                modifiers: [],
                                                type: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "InputStream"
                                                    }
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "in"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "MethodInvocation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "createInputStream"
                                                            },
                                                            arguments: []
                                                        }
                                                    }
                                                ]
                                            },
                                            {
                                                node: "VariableDeclarationExpression",
                                                modifiers: [],
                                                type: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "InputStream"
                                                    }
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "in2"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "MethodInvocation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "createInputStream"
                                                            },
                                                            arguments: []
                                                        }
                                                    }
                                                ]
                                            }
                                        ],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "MethodInvocation",
                                                        expression: {
                                                            node: "QualifiedName",
                                                            qualifier: {
                                                                node: "SimpleName",
                                                                identifier: "System"
                                                            },
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "out"
                                                            }
                                                        },
                                                        typeArguments: [],
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "println"
                                                        },
                                                        arguments: [
                                                            {
                                                                node: "SimpleName",
                                                                identifier: "in"
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        },
                                        catchClauses: [
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "IOException"
                                                        }
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "StringLiteral",
                                                                        escapedValue: "\"catch\""
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        ],
                                        finally: null
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [
                                            {
                                                node: "VariableDeclarationExpression",
                                                modifiers: [],
                                                type: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "InputStream"
                                                    }
                                                },
                                                fragments: [
                                                    {
                                                        node: "VariableDeclarationFragment",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "in"
                                                        },
                                                        extraDimensions: 0,
                                                        initializer: {
                                                            node: "MethodInvocation",
                                                            expression: null,
                                                            typeArguments: [],
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "createInputStream"
                                                            },
                                                            arguments: []
                                                        }
                                                    }
                                                ]
                                            }
                                        ],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "MethodInvocation",
                                                        expression: {
                                                            node: "QualifiedName",
                                                            qualifier: {
                                                                node: "SimpleName",
                                                                identifier: "System"
                                                            },
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "out"
                                                            }
                                                        },
                                                        typeArguments: [],
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "println"
                                                        },
                                                        arguments: [
                                                            {
                                                                node: "SimpleName",
                                                                identifier: "in"
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        },
                                        catchClauses: [],
                                        finally: null
                                    },
                                    {
                                        node: "TryStatement",
                                        resources: [],
                                        body: {
                                            node: "Block",
                                            statements: [
                                                {
                                                    node: "ExpressionStatement",
                                                    expression: {
                                                        node: "MethodInvocation",
                                                        expression: {
                                                            node: "QualifiedName",
                                                            qualifier: {
                                                                node: "SimpleName",
                                                                identifier: "System"
                                                            },
                                                            name: {
                                                                node: "SimpleName",
                                                                identifier: "out"
                                                            }
                                                        },
                                                        typeArguments: [],
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "println"
                                                        },
                                                        arguments: [
                                                            {
                                                                node: "StringLiteral",
                                                                escapedValue: "\"whatever\""
                                                            }
                                                        ]
                                                    }
                                                }
                                            ]
                                        },
                                        catchClauses: [
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "RuntimeException"
                                                        }
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "SimpleName",
                                                                        identifier: "e"
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            },
                                            {
                                                node: "CatchClause",
                                                exception: {
                                                    node: "SingleVariableDeclaration",
                                                    modifiers: [
                                                        {
                                                            node: "Modifier",
                                                            keyword: "final"
                                                        }
                                                    ],
                                                    type: {
                                                        node: "UnionType",
                                                        types: [
                                                            {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "Exception"
                                                                }
                                                            },
                                                            {
                                                                node: "SimpleType",
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "Error"
                                                                }
                                                            }
                                                        ]
                                                    },
                                                    varargs: false,
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "e"
                                                    },
                                                    extraDimensions: 0,
                                                    initializer: null
                                                },
                                                body: {
                                                    node: "Block",
                                                    statements: [
                                                        {
                                                            node: "ExpressionStatement",
                                                            expression: {
                                                                node: "MethodInvocation",
                                                                expression: {
                                                                    node: "QualifiedName",
                                                                    qualifier: {
                                                                        node: "SimpleName",
                                                                        identifier: "System"
                                                                    },
                                                                    name: {
                                                                        node: "SimpleName",
                                                                        identifier: "out"
                                                                    }
                                                                },
                                                                typeArguments: [],
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "println"
                                                                },
                                                                arguments: [
                                                                    {
                                                                        node: "SimpleName",
                                                                        identifier: "e"
                                                                    }
                                                                ]
                                                            }
                                                        }
                                                    ]
                                                }
                                            }
                                        ],
                                        finally: null
                                    },
                                    {
                                        node: "ReturnStatement",
                                        expression: {
                                            node: "MethodInvocation",
                                            expression: {
                                                node: "SimpleName",
                                                identifier: "JavaParser"
                                            },
                                            typeArguments: [],
                                            name: {
                                                node: "SimpleName",
                                                identifier: "parse"
                                            },
                                            arguments: [
                                                {
                                                    node: "SimpleName",
                                                    identifier: "file"
                                                }
                                            ]
                                        }
                                    }
                                ]
                            }
                        },
                        {
                            node: "TypeDeclaration",
                            modifiers: [],
                            interface: false,
                            name: {
                                node: "SimpleName",
                                identifier: "A"
                            },
                            typeParameters: [
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "T"
                                    },
                                    typeBounds: [
                                        {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Integer"
                                            }
                                        },
                                        {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Serializable"
                                            }
                                        }
                                    ]
                                }
                            ],
                            superclassType: null,
                            superInterfaceTypes: [
                                {
                                    node: "SimpleType",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "XXX"
                                    }
                                },
                                {
                                    node: "SimpleType",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "Serializable"
                                    }
                                }
                            ],
                            bodyDeclarations: [
                                {
                                    node: "MethodDeclaration",
                                    modifiers: [
                                        {
                                            node: "Modifier",
                                            keyword: "public"
                                        }
                                    ],
                                    constructor: true,
                                    typeParameters: [
                                        {
                                            node: "TypeParameter",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "ABC"
                                            },
                                            typeBounds: []
                                        }
                                    ],
                                    returnType2: null,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "A"
                                    },
                                    parameters: [
                                        {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [],
                                            type: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "Integer"
                                                }
                                            },
                                            varargs: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "integer"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        },
                                        {
                                            node: "SingleVariableDeclaration",
                                            modifiers: [],
                                            type: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "ABC"
                                                }
                                            },
                                            varargs: false,
                                            name: {
                                                node: "SimpleName",
                                                identifier: "string"
                                            },
                                            extraDimensions: 0,
                                            initializer: null
                                        }
                                    ],
                                    extraDimensions: 0,
                                    thrownExceptions: [
                                        {
                                            node: "SimpleName",
                                            identifier: "Exception"
                                        },
                                        {
                                            node: "SimpleName",
                                            identifier: "IOException"
                                        }
                                    ],
                                    body: {
                                        node: "Block",
                                        statements: []
                                    }
                                }
                            ]
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "private"
                                }
                            ],
                            constructor: false,
                            typeParameters: [
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "Y"
                                    },
                                    typeBounds: []
                                }
                            ],
                            returnType2: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "void"
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "x"
                            },
                            parameters: [
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "ParameterizedType",
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Map"
                                            }
                                        },
                                        typeArguments: [
                                            {
                                                node: "WildcardType",
                                                bound: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "X"
                                                    }
                                                },
                                                upperBound: true
                                            },
                                            {
                                                node: "WildcardType",
                                                bound: {
                                                    node: "SimpleType",
                                                    name: {
                                                        node: "SimpleName",
                                                        identifier: "T"
                                                    }
                                                },
                                                upperBound: false
                                            }
                                        ]
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "x"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ],
                            extraDimensions: 0,
                            thrownExceptions: [],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "VariableDeclarationStatement",
                                        modifiers: [
                                            {
                                                node: "MarkerAnnotation",
                                                typeName: {
                                                    node: "SimpleName",
                                                    identifier: "Deprecated"
                                                }
                                            }
                                        ],
                                        type: {
                                            node: "SimpleType",
                                            name: {
                                                node: "SimpleName",
                                                identifier: "Comparator"
                                            }
                                        },
                                        fragments: [
                                            {
                                                node: "VariableDeclarationFragment",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "c"
                                                },
                                                extraDimensions: 0,
                                                initializer: {
                                                    node: "ClassInstanceCreation",
                                                    expression: null,
                                                    typeArguments: [],
                                                    type: {
                                                        node: "SimpleType",
                                                        name: {
                                                            node: "SimpleName",
                                                            identifier: "Comparator"
                                                        }
                                                    },
                                                    arguments: [],
                                                    anonymousClassDeclaration: {
                                                        node: "AnonymousClassDeclaration",
                                                        bodyDeclarations: [
                                                            {
                                                                node: "MethodDeclaration",
                                                                modifiers: [
                                                                    {
                                                                        node: "Modifier",
                                                                        keyword: "public"
                                                                    }
                                                                ],
                                                                constructor: false,
                                                                typeParameters: [],
                                                                returnType2: {
                                                                    node: "PrimitiveType",
                                                                    primitiveTypeCode: "int"
                                                                },
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "compare"
                                                                },
                                                                parameters: [
                                                                    {
                                                                        node: "SingleVariableDeclaration",
                                                                        modifiers: [],
                                                                        type: {
                                                                            node: "SimpleType",
                                                                            name: {
                                                                                node: "SimpleName",
                                                                                identifier: "Object"
                                                                            }
                                                                        },
                                                                        varargs: false,
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "o1"
                                                                        },
                                                                        extraDimensions: 0,
                                                                        initializer: null
                                                                    },
                                                                    {
                                                                        node: "SingleVariableDeclaration",
                                                                        modifiers: [],
                                                                        type: {
                                                                            node: "SimpleType",
                                                                            name: {
                                                                                node: "SimpleName",
                                                                                identifier: "Object"
                                                                            }
                                                                        },
                                                                        varargs: false,
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "o2"
                                                                        },
                                                                        extraDimensions: 0,
                                                                        initializer: null
                                                                    }
                                                                ],
                                                                extraDimensions: 0,
                                                                thrownExceptions: [],
                                                                body: {
                                                                    node: "Block",
                                                                    statements: [
                                                                        {
                                                                            node: "TryStatement",
                                                                            resources: [],
                                                                            body: {
                                                                                node: "Block",
                                                                                statements: [
                                                                                    {
                                                                                        node: "VariableDeclarationStatement",
                                                                                        modifiers: [],
                                                                                        type: {
                                                                                            node: "ParameterizedType",
                                                                                            type: {
                                                                                                node: "SimpleType",
                                                                                                name: {
                                                                                                    node: "SimpleName",
                                                                                                    identifier: "A"
                                                                                                }
                                                                                            },
                                                                                            typeArguments: [
                                                                                                {
                                                                                                    node: "SimpleType",
                                                                                                    name: {
                                                                                                        node: "SimpleName",
                                                                                                        identifier: "Integer"
                                                                                                    }
                                                                                                }
                                                                                            ]
                                                                                        },
                                                                                        fragments: [
                                                                                            {
                                                                                                node: "VariableDeclarationFragment",
                                                                                                name: {
                                                                                                    node: "SimpleName",
                                                                                                    identifier: "a"
                                                                                                },
                                                                                                extraDimensions: 0,
                                                                                                initializer: {
                                                                                                    node: "ClassInstanceCreation",
                                                                                                    expression: null,
                                                                                                    typeArguments: [
                                                                                                        {
                                                                                                            node: "SimpleType",
                                                                                                            name: {
                                                                                                                node: "SimpleName",
                                                                                                                identifier: "String"
                                                                                                            }
                                                                                                        }
                                                                                                    ],
                                                                                                    type: {
                                                                                                        node: "ParameterizedType",
                                                                                                        type: {
                                                                                                            node: "SimpleType",
                                                                                                            name: {
                                                                                                                node: "SimpleName",
                                                                                                                identifier: "A"
                                                                                                            }
                                                                                                        },
                                                                                                        typeArguments: [
                                                                                                            {
                                                                                                                node: "SimpleType",
                                                                                                                name: {
                                                                                                                    node: "SimpleName",
                                                                                                                    identifier: "Integer"
                                                                                                                }
                                                                                                            }
                                                                                                        ]
                                                                                                    },
                                                                                                    arguments: [
                                                                                                        {
                                                                                                            node: "ClassInstanceCreation",
                                                                                                            expression: null,
                                                                                                            typeArguments: [],
                                                                                                            type: {
                                                                                                                node: "SimpleType",
                                                                                                                name: {
                                                                                                                    node: "SimpleName",
                                                                                                                    identifier: "Integer"
                                                                                                                }
                                                                                                            },
                                                                                                            arguments: [
                                                                                                                {
                                                                                                                    node: "NumberLiteral",
                                                                                                                    token: "11"
                                                                                                                }
                                                                                                            ],
                                                                                                            anonymousClassDeclaration: null
                                                                                                        },
                                                                                                        {
                                                                                                            node: "StringLiteral",
                                                                                                            escapedValue: "\"foo\""
                                                                                                        }
                                                                                                    ],
                                                                                                    anonymousClassDeclaration: {
                                                                                                        node: "AnonymousClassDeclaration",
                                                                                                        bodyDeclarations: []
                                                                                                    }
                                                                                                }
                                                                                            }
                                                                                        ]
                                                                                    }
                                                                                ]
                                                                            },
                                                                            catchClauses: [
                                                                                {
                                                                                    node: "CatchClause",
                                                                                    exception: {
                                                                                        node: "SingleVariableDeclaration",
                                                                                        modifiers: [],
                                                                                        type: {
                                                                                            node: "SimpleType",
                                                                                            name: {
                                                                                                node: "SimpleName",
                                                                                                identifier: "Exception"
                                                                                            }
                                                                                        },
                                                                                        varargs: false,
                                                                                        name: {
                                                                                            node: "SimpleName",
                                                                                            identifier: "e"
                                                                                        },
                                                                                        extraDimensions: 0,
                                                                                        initializer: null
                                                                                    },
                                                                                    body: {
                                                                                        node: "Block",
                                                                                        statements: []
                                                                                    }
                                                                                }
                                                                            ],
                                                                            finally: null
                                                                        },
                                                                        {
                                                                            node: "ReturnStatement",
                                                                            expression: {
                                                                                node: "NumberLiteral",
                                                                                token: "0"
                                                                            }
                                                                        }
                                                                    ]
                                                                }
                                                            },
                                                            {
                                                                node: "MethodDeclaration",
                                                                modifiers: [
                                                                    {
                                                                        node: "MarkerAnnotation",
                                                                        typeName: {
                                                                            node: "SimpleName",
                                                                            identifier: "Override"
                                                                        }
                                                                    },
                                                                    {
                                                                        node: "Modifier",
                                                                        keyword: "public"
                                                                    }
                                                                ],
                                                                constructor: false,
                                                                typeParameters: [],
                                                                returnType2: {
                                                                    node: "PrimitiveType",
                                                                    primitiveTypeCode: "boolean"
                                                                },
                                                                name: {
                                                                    node: "SimpleName",
                                                                    identifier: "equals"
                                                                },
                                                                parameters: [
                                                                    {
                                                                        node: "SingleVariableDeclaration",
                                                                        modifiers: [],
                                                                        type: {
                                                                            node: "SimpleType",
                                                                            name: {
                                                                                node: "SimpleName",
                                                                                identifier: "Object"
                                                                            }
                                                                        },
                                                                        varargs: false,
                                                                        name: {
                                                                            node: "SimpleName",
                                                                            identifier: "obj"
                                                                        },
                                                                        extraDimensions: 0,
                                                                        initializer: null
                                                                    }
                                                                ],
                                                                extraDimensions: 0,
                                                                thrownExceptions: [],
                                                                body: {
                                                                    node: "Block",
                                                                    statements: [
                                                                        {
                                                                            node: "ReturnStatement",
                                                                            expression: {
                                                                                node: "SuperMethodInvocation",
                                                                                qualifier: null,
                                                                                typeArguments: [],
                                                                                name: {
                                                                                    node: "SimpleName",
                                                                                    identifier: "equals"
                                                                                },
                                                                                arguments: [
                                                                                    {
                                                                                        node: "SimpleName",
                                                                                        identifier: "obj"
                                                                                    }
                                                                                ]
                                                                            }
                                                                        }
                                                                    ]
                                                                }
                                                            }
                                                        ]
                                                    }
                                                }
                                            }
                                        ]
                                    }
                                ]
                            }
                        },
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "private"
                                },
                                {
                                    node: "Modifier",
                                    keyword: "static"
                                }
                            ],
                            constructor: false,
                            typeParameters: [],
                            returnType2: {
                                node: "SimpleType",
                                name: {
                                    node: "SimpleName",
                                    identifier: "InputStream"
                                }
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "createInputStream"
                            },
                            parameters: [],
                            extraDimensions: 0,
                            thrownExceptions: [],
                            body: {
                                node: "Block",
                                statements: [
                                    {
                                        node: "ReturnStatement",
                                        expression: {
                                            node: "ClassInstanceCreation",
                                            expression: null,
                                            typeArguments: [],
                                            type: {
                                                node: "SimpleType",
                                                name: {
                                                    node: "SimpleName",
                                                    identifier: "ByteArrayInputStream"
                                                }
                                            },
                                            arguments: [
                                                {
                                                    node: "NullLiteral"
                                                }
                                            ],
                                            anonymousClassDeclaration: null
                                        }
                                    }
                                ]
                            }
                        }
                    ]
                },
                {
                    node: "TypeDeclaration",
                    modifiers: [],
                    interface: false,
                    name: {
                        node: "SimpleName",
                        identifier: "Base"
                    },
                    typeParameters: [],
                    superclassType: null,
                    superInterfaceTypes: [],
                    bodyDeclarations: [
                        {
                            node: "MethodDeclaration",
                            modifiers: [
                                {
                                    node: "Modifier",
                                    keyword: "public"
                                }
                            ],
                            constructor: false,
                            typeParameters: [
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "A"
                                    },
                                    typeBounds: []
                                },
                                {
                                    node: "TypeParameter",
                                    name: {
                                        node: "SimpleName",
                                        identifier: "B"
                                    },
                                    typeBounds: []
                                }
                            ],
                            returnType2: {
                                node: "PrimitiveType",
                                primitiveTypeCode: "void"
                            },
                            name: {
                                node: "SimpleName",
                                identifier: "check2"
                            },
                            parameters: [
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "A"
                                        }
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "val1"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                },
                                {
                                    node: "SingleVariableDeclaration",
                                    modifiers: [],
                                    type: {
                                        node: "SimpleType",
                                        name: {
                                            node: "SimpleName",
                                            identifier: "B"
                                        }
                                    },
                                    varargs: false,
                                    name: {
                                        node: "SimpleName",
                                        identifier: "val2"
                                    },
                                    extraDimensions: 0,
                                    initializer: null
                                }
                            ],
                            extraDimensions: 0,
                            thrownExceptions: [],
                            body: {
                                node: "Block",
                                statements: []
                            }
                        }
                    ]
                },
                {
                    node: "TypeDeclaration",
                    modifiers: [],
                    interface: true,
                    name: {
                        node: "SimpleName",
                        identifier: "XXX"
                    },
                    typeParameters: [],
                    superclassType: null,
                    superInterfaceTypes: [
                        {
                            node: "SimpleType",
                            name: {
                                node: "SimpleName",
                                identifier: "Serializable"
                            }
                        },
                        {
                            node: "SimpleType",
                            name: {
                                node: "SimpleName",
                                identifier: "Cloneable"
                            }
                        }
                    ],
                    bodyDeclarations: []
                }
            ]
        }
 );
    });